Cream of the Crop 20/Cream of the Crop 20 (Terry Blount) (1996).iso/editor/doc6_2.zip/DR6DOC.ASC

Text File | 1996-05-05 | 66KB | 1,302 lines

                         SOFTWARE BY SEIDMAN'S

                         DOCTOR 6  Version 2.0

                 The File Doctor for WordPerfect(r) 6.0


                              Introduction


Things can go wrong with WordPerfect 6 DOS and Windows document files.
Text may disappear.  WordPerfect 6 (WPerf6) may stop recognizing a file
as a WPerf6 document file. The program may lock up when you retrieve
the file.  Windows may throw a GPF.  And other strange things may
happen. We don't always know why they happen, but we can often do
something about them when they do.

If your WPerf6 files get sick, Doctor 6, the File Doctor for
WordPerfect 6, may be able to help. It cannot help if what should be in
your file has simply vanished from your disk, but that is not what
usually happens.  Check the size of your file with the DOS DIR command
or the WPerf file manager.  If the number of bytes is not too small,
your text is probably still there, and it is time to call the File
Doctor.  Doctor 6 cannot cure all the maladies that may afflict
WordPerfect files, but it can cure many of them.  Doctor 6 is
shareware.  Please register your copy.

Doctor 6 has a number of different ways of diagnosing problems and
operating on files.  One or more of these ways may be necessary to cure
any particular file's problems.  This document explains how to use the
program and how to select among the various ways of curing files. Those
who are familiar with WPMD, the File Doctor for WordPerfect 5, will
recognize some but not all of these methods.  WordPerfect 6 files are
more complicated than WordPerfect 5 files, and the techniques of
surgery are therefore more complicated.  Some files are easily fixed by
use of a single method.  Others require more elaborate approaches.

The registered Doctor 6 package includes SaveText, a computer program
that sometimes helps save text that otherwise might be lost when Doctor
6 operates, as well as TestSix, an executable program, and Test6, a
DLL.  TestSix performs all the diagnostic functions of Doctor 6, and it
can test large numbers of files at high speed.  Test6 allows you to
write WordPerfect for Windows macros (or programs in languages that can
call functions in DLLs) that perform these diagnostic functions.

Doctor 6, SaveText, and TestSix run under MS-DOS (version 2.1 or
higher) and compatible operating systems.  Doctor 6 requires
approximately 400K of free memory to operate; the other programs
require less memory.  Test6 is a Windows 3.1 DLL.  No particular
installation procedures are required; the programs must merely reside
in some directory, prefererably on your hard disk.

NOTE:  This product is not manufactured, approved, or supported by
WordPerfect Corp,, Novell Corp., or Corel Corp.  WordPerfect is a
registered trademark of one of those three companies.



                      WordPerfect 6 File Structure

To cure the ills of a WordPerfect 6 file, it helps to know a bit about
the structure of a WordPerfect 6 document file.  The file has two main
parts, the "prefix" and the "body."  The prefix, which can be very
large, contains all sorts of miscellaneous information, such as styles,
identification of the PRS file, and proportional spacing tables for
fonts.  It also may contain a good deal of material that in WordPerfect
5 was part of the body of the document.  For example, the text of
footnotes, endnotes, and text boxes is found in the prefix, not the
body.

The body of the document contains everything else.  It helps to think
of the body as containing everything typed in by the user, but this is
not quite correct, because some of what the user types in goes into the
prefix, as indicated above.  The body contains text, formatting codes,
and references to material in the prefix.  Ordinary keyboard
characters, for the most part, appear in the file simply as those
characters (the main exception being the space, which appears as a Ç
when viewed in many other programs).  Everything else is a code, and
its appearance when viewed in another program gives no indication of
what it is.  Codes can be quite complex, and they may include
references to material in the prefix.  Separate the prefix from the
body (as you may do with Doctor 6) and the body is missing much of what
is necessary for a complete document.

Any of these elements can go bad.  The structures by which WPerf6 keeps
track of the elements in the prefix can go haywire.  Individual codes
can take on improper values, so that WPerf6 becomes confused.  Body
references to prefix elements can become incorrect (and often will as
you use Doctor 6), leaving WPerf searching for what is not there at
all, or is in an unexpected and unfindable place.  Understanding these
possibilities will help you figure out how best to fix the file.

                             Using Doctor 6


Doctor 6 is a DOS program (although it will run as a DOS program under
Windows).  To run it, type the name of the executable file at the DOS
prompt and press Enter (or use one of the available means of starting
DOS programs under Windows):

                            C:\DR6>DOCTOR6

The program displays its main menu:


╒═══════════════════Software by Seidman's Doctor 6  Ver. 2.0═══════════════════╕
│  File     Diagnose     Operate    Quit (F7, Esc)              Help (F1)      │
│                                                                              │
╘═════════Copyright 1994-1996 by David Seidman -- All Rights Reserved══════════╛


Select main menu options by typing their first letter or by using the
cursor movement keys to highlight your choice and then hitting enter.

Most of what you do will be from the Diagnose and Operate submenus, and
these are described below.  The File submenu is helpful but not
necessary.  Quit has no submenu, and you can use the F7 or Esc keys to
quit the program without using the Quit menu entry.  You can enter Help
either from the menu or by using the F1 key.  Select Help on Help from
the Help submenu for more instructions.  Exit from Help with Esc
(repeated, if necessary).


I. FILE Submenu

Selecting the File menu choice produces the following submenu, from
which you can select with first letters or cursor movement with the
Enter key:

                            ╒═════════════╕
                            │ Input File  │
                            │ Output File │
                            │ Quit        │
                            ╘═════════════╛

Input File

The Input File is the problem file you wish to diagnose or operate on.
You must provide its name. If you do not do so from the File submenu,
any Diagnose or Operation option will prompt you as if you had selected
the Input File menu item.

When you select Input File (or when the program otherwise decides it
needs an input file name), you will be prompted this way:

                       Input File Name: *.*

If you hit the Enter key, you will be presented with a list of all the
files in the default directory. Move the cursor to the file name you
want to select and hit the ENTER key.  The selected file name will
appear as the response to the program's request for an input file name.
You can then edit it or hit the ENTER key to accept it.  Alternatively,
you can ignore the initially proposed *.* and type the name (including
drive and directory, if necessary) of the file you wish to fix.  When
you have finished typing and editing the file name (conventional
editing keys work), hit the ENTER key.  If you include a DOS wildcard
(* or ?) in the filename, you will be presented with a list of files
matching the file specification, from which you can select by hitting
the ENTER key.  (For details on editing the file name, hit F1 for
context sensitive help.)

If you change your mind and do not wish to selecting an input file,
make your response to the prompt blank and hit ENTER.

Output File

Doctor 6 does not change the input file in any way.  All changes it
makes are written to an output file.  You can provide the output file
name by selecting the Output File option from the File submenu.  If you
do not do so, any program option requiring an output file will prompt
you for the output file name.

When this option is selected (or the program needs an output file
name), Doctor 6 will ask you for the name of an output file, the fixed
file it is to create.  It will propose a file name, which you can
accept by hitting the ENTER key.  Usually, the name it proposes will be
the name (including path) of the input file, but with the extension
FIX.  If a file with that name already exists, Doctor 6 will try
extensions from X01 to X99.  If all of those are in use with that file
name, Doctor 6 will not propose a file name.  If you like the proposal
but would like to edit it a bit, move the cursor with an arrow key
before doing any editing.  If you do not like the proposal and would
like to enter a new name, just start typing; the proposed name will
vanish.  If you would like to restore the original proposal, hit Ctrl-
R.

If there are problems with the input or output file name you supply,
Doctor 6 will ask you to take corrective action.  It should be obvious
how to respond.

Quit

Selecting this submenu option will cause an exit from the program
(although you will be asked to confirm your choice).  It usually will
be more convenient to use other ways to exit.


II.     DIAGNOSE Submenu

Selecting the Diagnose menu choice produces the following submenu, from
which you can select with first letters or cursor movement with the
Enter key:

                          ╒═════════════════╕
                          │ Prefix Check    │
                          │ Bad Code Check  │
                          │ Reference Check │
                          │ Undo Check      │
                          ╘═════════════════╛


Do NOT select Reference Check or Undo Check until you know there are no
remaining bad codes in the document file.

Note that not every condition that Doctor 6 can fix is subject to
diagnosis.  It is useful to begin by testing for problems that can be
diagnosed, but when diagnosis fails, you have to experiment with cures.

Prefix Check

Prefix Check diagnoses a number of structural problems in the document
prefix.  If Doctor 6 finds structural problems in the prefix, it
identifies them.  Usually, the only cure is Drastic Surgery (see
below).  However, if the structural problem found is only that the file
is not properly identified internally as a WordPerfect 6 file, Doctor 6
offers you the opportunity to change that internal identification (and,
if you have not yet supplied an output file name, asks for an output
file name if you do want to change the identification).  It is unlikely
that an otherwise structurally sound prefix has improper
identification, so you are not likely to be offered this opportunity.

Because structural prefix problems may make it impossible for Doctor 6
to perform its other functions, a Prefix Check should precede any other
diagnoses or operations on an input file (although it is not necessary
before Drastic Surgery or Erase Selected Prefix Data).  But it is not
necessary to select Prefix Check explicitly; if you fail to do so, the
other program options (other than Drastic Surgery and Erase Selected
Prefix Data) will do it automatically.

Bad Code Check

WPerf6 function codes are stored as series of bytes that have meaning
to WPerf6, not as what you see in Reveal Codes.  If even one byte in a
code is incorrect (or if there is a byte that WPerf6 thinks is part of
a code even though it is not), WPerf6 can get hopelessly confused.
This confusion can have dramatic results.  For example, the entire text
of your document may disappear from the screen; even though the text is
actually all there in the file, WPerf6 shows nothing but a blank
screen.  Or you may lose part of the text, a "loop" may develop so that
moving the cursor down in the document brings you to an earlier part of
it, the program may lock up, or the text may become incorrect in other
ways.  If you are in Windows, a GPF may occur.

Bad Code Check tests for bytes that can cause this kind of problem and
reports whether there are any.  If there are bad codes, you should next
choose Cure Corrupted Data from the Operate menu.

It is possible that Bad Code Check will miss certain kinds of bad
codes.  If all else fails, you can run Cure Corrupted Data even though
Bad Code Check found no problems.

As explained above, some document text is stored in the document
prefix.  Bad Code Check usually checks for bad codes in the text stored
in the document prefix.  However, in some cases it does not, because it
is unable to process the "packet" storing the data.  That probably
indicates that internal information about the data packet has been
corrupted.  Bad Code Check reports the sequence number of the first ten
unprocessed packets.  You should probably delete them using Erase
Selected Prefix Data.

Use Bad Code Check BEFORE using Reference Check or Undo Check.  If bad
codes are found, use Cure Corrupted Data BEFORE using Reference Check
or Undo Check.  Corrupted data in the document file can cause problems
for some Doctor 6 functions, just as corrupted data can cause problems
for WPerf6.

Reference Check

Reference Check checks for invalid references to portions of the
prefix.  (It cannot test for all possible invalid references, however.)
Not all bad references cause problems for WordPerfect. But if there are
bad references and no other obvious problems, and the file does not
work, you should try using Remove Bad References on the Operate
submenu.

Corrupted data in a document may lead Reference Check to give spurious
results (or worse). Therefore, you should use Bad Code Check before
using Reference Check, and if there are bad codes, you should Cure
Corrupted Data before running Reference Check.  Like Bad Code Check,
Reference Check may fail to process certain prefix data.  Unlike Bad
Code Check, Reference Check does not report the unprocessed data
packets (because you should use Bad Code Check before using Reference
Check, so you will know about these packets).

Undo Check

If a document is created with Allow Undo selected in WPerf6, WPerf6
stores deleted material in the document file so it can later undo what
you did.  If the document becomes corrupted, WPerf6 could become
confused about what portions of the document are valid and what
portions are merely stored for later use by the undo function.  In
theory, it would be possible for WPerf6 to treat valid data as data
stored for use by undo.  The result would be to make valid data
invisible and unusable.

It is not always possible to tell whether this has happened.  However,
one way to test for the possibility is to look for what we term
"unbalanced undo codes."  That is what Undo Check does. If it finds
unbalanced undo codes, you should run Undo Undo from the Operate
submenu.

Do NOT use Undo Check until you have run Bad Code Check and, if
necessary, Cure Corrupted Data.


III.    OPERATE Submenu


Selecting the Operate menu choice produces the following submenu, from
which you can select with first letters or cursor movement with the
Enter key:

                     ╒════════════════════════════╕
                     │ Cure Corrupted Data        │
                     │ Remove Bad References      │
                     │ Erase Selected Prefix Data │
                     │ Strip Debris               │
                     │ Drastic Surgery            │
                     │ Undo Undo                  │
                     │ Kill Pair Codes            │
                     │ Fix Spurious Password      │
                     ╘════════════════════════════╛

Except for minor problems in prefix structure, fixed in Check Prefix
Structure on the Diagnose submenu, this submenu is where you actually
fix problems in your document.

It may be necessary to use more than one method of operating to fix any
particular file.  This requires some care in the management of input
and output files.  For example, if you start with the input file
BADFILE and Cure Corrupted Data, by default you would create
BADFILE.FIX in the process.  If you also need to Remove Bad References,
you would not use BADFILE as the input file for Remove Bad References.
Rather, you would use BADFILE.FIX as the input file, creating (by
default) BADFILE.X01 as the output file.  If you used BADFILE as the
input file for both operations, you would either overwrite one output
file with the other, or else create two output files, one with the
corrupted data fixed, and one with the bad references fixed.  That
would probably not be what you want.  Multiple operations work in
sequence; each should use as its input file the output of the previous
operation.


Cure Corrupted Data

Cure Corrupted Data searches both the prefix and the body of the file
for bad codes of the sort reported by Bad Code Check. Usually when it
finds them, it deletes them and leaves the message **FIX** in their
place.  After you retrieve the fixed file into WPerf6, search for
**FIX** (use an Extended Search, because Cure Corrupted Data may have
fixed a problem in a footnote, endnote, header, footer, or text box),
and see if anything is missing at that point.  At least one code is
likely to be missing.  In addition, you will often see garbage --
erroneous characters and codes -- after the **FIX** message.  The
garbage is the remains of broken codes.  Simply delete it.

In a style stored in the prefix becomes corrupted and Doctor 6 fixes
it, these fixes are not reflected in the body of the document when the
document is retrieved (unless the corruption is also found in teh
document where the style is used).  If you edit the style, howver,
these changes will be reflected in the document.

In very rare cases, Cure Corrupted Data will cure a problem without
leaving a **FIX** message. This happens primarily when it figures out
exactly what the incorrect bytes should be and replaces them with the
correct ones.

Cure Corrupted Data also removes certain unnecessary codes (unnecessary
because WPerf6 will replace them automatically) without leaving a
message.  These unnecessary codes can become corrupted in ways Doctor 6
cannot identify.  That is why the Doctor removes them all.  Thus Cure
Corrupted Data may fix problems that Bad Code Check cannot identify.
You should therefore consider using Cure Corrupted Data even when Bad
Code Check does not find a problem.

Like Bad Code Check, Cure Corrupted Data may fail to process certain
prefix data.  Also like Bad Code Check, it reports the numbers of the
data packets it fails to process, so you can, if necessary, delete them
using Erase Selected Prefix Data.

Curing corrupted data may fully fix the problems in a file, but even
where the problem is basically corrupted data, this single operation
may not be sufficient.  After curing the corrupted data, you should at
least use Bad Reference Check and Undo Check to see if there are any
obvious problems (remember to change the Input File to the output of
Cure Corrupted Data before doing so).  If the file passes these tests
but still does not work correctly in WPerf6, try Strip Debris on the
Operate submenu.  We have seen cases where a file with no remaining
problems indicated by the Diagnose options nevertheless causes WPerf6
to lock up, and Strip Debris sometimes fully cures the remaining
problems.  Kill Pair Codes is also sometimes helpful in these
situations.

Remove Bad References

Bad references to portions of the document prefix, as found by Bad
Reference Check, can cause serious problems for WPerf6, although they
do not necessarily do so. In principle, the best way to handle them
would be to replace them by valid references to portions of the prefix.
Unfortunately, when Doctor 6 finds a bad reference, it has no way of
knowing what the correct reference would be.  Therefore, it has no
alternative to deleting the code that contains the bad reference.  That
is what Remove Bad References does.

Removing bad references causes some damage to a file.  Therefore, even
if the file is known to contain bad references, you should not
automatically remove them.  Try retrieving the file into WPerf6 before
removing them.  If WPerf6 can handle the file, do not remove the bad
references. You might also try Cure Corrupted Data, Strip Debris, and
Kill Pair Codes before removing the bad references.

When Remove Bad References deletes a code in a portion of the document
to which a WPerf6 user normally has access, it optionally leaves the
message **BadRef** in the document.  (You are asked whether you want to
mark deleted bad references when you run Remove Bad References.) When
you retrieve the document, if you have used this option, do an Extended
Search for **BadRef** so you can delete the messages, see if there is
any remaining garbage that needs to be deleted, and attempt to replace
the deleted code with a proper one.  This can be useful if there are
only a few bad references.  However, if the bad references are numerous
(as they certainly will be if you used Drastic Surgery), looking at the
**BadRef** marks littering your document is not worth the effort.

In theory, it is possible for a pass through Remove Bad References to
create some bad references in the process of removing others.  To guard
against this unlikely possibility, you should do a Bad Reference Check
on the Remove Bad References output file if Remove Bad References did
not fully cure the file.

Removing bad references can cause other problems in a document, because
the code containing the bad references may be paired with other codes;
WPerf6 can get confused if one member of the pair is missing.  It may
therefore be necessary to Kill Pair Codes after removing bad
references.

Note that Remove Bad References, like Reference Check, may fail to
process certain prefix data.

Erase Selected Prefix Data

Sometimes you can determine that a problem is caused by something in
the document prefix, but Doctor 6 cannot diagnose the problem.  You
can, for example, be reasonably certain that the problem has to do with
the prefix if Doctor 6's Diagnose submenu finds no problem, Strip
Debris and Undo Undo do not cure the problem, and Drastic Surgery
produces a working file.  You could cure the problem with the least
damage to your file by deleting only that piece of the prefix that is
causing the problem.  Of course, you probably do not know which portion
of the prefix is causing the problem, but there is always trial and
error, perhaps informed by hunch.  If Bad Code Check failed to process
certain prefix data packets, a reasonable hunch is that remaining
problems are related to those data packets.

To allow you to fix as many prefix problems as possible, Doctor 6
permits you to run Erase Selected Prefix Data even if the document
prefix is structurally bad, provided that either the bytes identifying
the file as a WPerf6 document file are intact (perhaps after they are
fixed in Prefix Check).  This is risky, however.  Certain kinds of
problems in the prefix may cause Doctor 6 to crash, just as they cause
WPerf6 to crash.  Be careful.

Erase Selected Prefix Data allows you to delete selected portions of a
document prefix.  When you choose this option, you are presented with a
list from which you can pick the portions (or "data packets") to
delete.  Here is an example of such a list:


╒       Size    Uses    Type══════════════════════════════════════╕
│   1:       23    1 Comment/Annotation                           │
│   2:        6    1 Initial Font                                 │
│   3:      152    2 Style Data                                   │
│   4:      264    9 Style Data                                   │
│   5:      255   15 Style Data                                   │
│   6:           [DELETED]                                        │
│   7:     1214    1 General WP Text                              │
│   8:      146    3 Style Data                                   │
│   9:        6    1 Bookmark Data                                │
│  10:      140   10 Style Data                                   │
│  11:      154    2 Style Data                                   │
│  12:      240    2 Style Data                                   │
│  13:      107    8 Outline Style                                │
│  14:      140    3 Style Data                                   │
│  15:      212    5 Style Data                                   │
│  16:       46   29 Desired Font                                 │
│  17:      109    1 Outline Style                                │
│  18:       61   23 Style Data                                   │
│  19:       70   10 Desired Font                                 │
│  20:       46    1 Desired Font                                 │
│  21:       29    6 Border Line Style                            │
│  22:       12    1 Document Height                              │
╘═════════════════════════════════════════════════════════   More╛


The first column has the sequence number of the data packet.  The next
column, Size, indicates the number of bytes the prefix data packet
takes up.  The Uses column indicates the number of times other parts of
the document call upon that data packet.  The Type column indicates the
nature of the packet.  (The meaning of the types is not always obvious.
It is beyond the scope of this documentation to explain each of the
types.)  Any deleted packets are so indicated.  Note that if the size
seems unlikely, it may be incorrect.  (Prefix Check may have shown a
problem as a result of such an error.)

You select packets for deletion by moving the highlight to the desired
line and hitting the Insert key (you can also use the space bar, which
toggles selection).  After you have selected one or more packets, hit
the Enter key to accept your selections.  (See the context sensitive
help for more information on selecting from the list.)

Deleting data packets may result in bad references.  As usual, see if
the file works in WPerf6 before removing the bad references.

Strip Debris

Strip Debris removes from the file material stored for the Undo
function and some unnecessary formatting information (unnecessary
because WPerf6 replaces it automatically).  No test is available to
determine when this option is likely to fix a file.  The option should
therefore be used after other methods prove insufficient, or when no
other method seems indicated.  In particular, it may be helpful to
Strip Debris from the output file created by Cure Corrupted Data.

Removing material stored for the undo function can be dangerous.  If
the codes marking this material are incorrect, Strip Debris can delete
valid text.  Undo check provides some safeguard against this
possibility, but not a perfect safeguard.  If after using Strip Debris,
it appears that too much text has vanished, go back to the version of
the file you used as input to Strip Debris and try Undo Undo instead.

Drastic Surgery

Drastic Surgery amputates the document prefix, the beginning part of
the document file you do not see in WPerf6, and replaces it with
another document prefix.  This amputation loses a good deal of
information, including graphics, styles, footnotes, endnotes, boxes,
headers, footers, and more.  This loss is not a good thing, and
therefore you should not undertake Drastic Surgery lightly.  Use it
only when other approaches do not work.

In some cases, you may be able to preserve text stored in your prefix
(footnotes, comments, box contents, and so forth) by using SaveText, a
separate computer program described below. However, while SaveText may
be able to preserve the text, the text will not be preserved as part of
your document.

If the only problem is a problem in the prefix, Drastic Surgery may be
all the cure you need.  But Drastic Surgery may simply allow WPerf6 to
get to the rest of the document, where there could also be problems.
So if Drastic Surgery does not fully cure your file, try the other
approaches again, using the Drastic Surgery output as the input file.
In particular, it is certain that use of Drastic Surgery will result in
bad references in the body of the document.  Often these bad references
will result in no problem, but if WPerf6 cannot handle the Drastic
Surgery output file, you may want to remove the bad references from it.
There are likely to be so many bad references that you will not want to
let the Doctor mark them all in your document.

Normally, Drastic Surgery replaces the existing document prefix with a
very minimal prefix containing no useful information.  However, you are
given the opportunity to tell the program to use a prefix taken from
another file.  If you chose this option, you supply the program with
the name of another file, and Doctor 6 copies the prefix from that
file.  You would do this if you think another file has a prefix
identical to the one that is, or should be, in the sick file.
Unfortunately, it is highly unlikely that two different files have
identical, or even nearly identical, prefixes.  Even if two prefixes
contain the same styles, footnotes, boxes, and so forth, the
information is not likely to be in precisely the same places in the two
different prefixes.  And if the information is not precisely where the
body of the document expects it to be, it might as well not be there at
all. Therefore, you are not likely to find this option useful.

In order to amputate the existing prefix and put a new prefix before
the body of your document, Drastic Surgery needs to know the "offset,"
the location, in the file where the body of your document begins (or,
equivalently, where the existing prefix ends).  That information is
stored very close to the beginning of a normal WordPerfect document.
Of course, you would not be using Drastic Surgery if your document were
a normal WordPerfect document.  Therefore, the information stored in
the file where the offset of the start of the text is supposed to be
stored may not be valid.  Nevertheless, that information is worth
trying.

Doctor 6 reads that information.  If it thinks that the information
indicates a plausible file offset, it asks you whether you want to try
Drastic Surgery using that offset.  To help you decide whether to try
that offset, the Doctor also tells you the number of bytes there would
be in the body of your document if that were the offset of the
beginning of the body.  If you think that number of bytes is at all
plausible, you might as well run Drastic Surgery using that offset.  At
best, it is the right offset (and in our experience it usually is the
right offset).  At worst, it is wrong, the output file is not very
good, and you try Drastic Surgery again.  In other words, let the
Doctor try Drastic Surgery with the internally stored offset
information unless you have a very good reason not to.

The usual good reason is that you have already tried that once.  There
can be other good reasons. If the file you are trying to fix is a 200
page document and the Doctor says that, based on the internally-stored
offset, the text of the file is 500 bytes, the internally stored value
is not likely to be right.

If you decide not to use the offset stored internally, you have to tell
the Doctor where the body of the document begins.  So that you can do
this, the Doctor displays your file in a conventional "hex mode"
manner.  As an example, we use a simple file, which contains nothing
but the sentence "This is an example."  The first part of the hex mode
display looks like this:

╒══════════════════════════════════════════════════════════════════════════════╕
│000000   FF 57 50 43 57 04 00 00 01 0A 02 00 00 00 00 00   .WPCW...........   │
│000010   02 00 17 00 00 00 00 00 00 00 00 00 00 00 00 09   ................   │
│000020   01 00 00 00 06 00 00 00 52 01 00 00 08 01 01 00   ........R.......   │
│000030   00 00 0C 00 00 00 6D 03 00 00 08 02 01 00 00 00   ......m.........   │
│000040   10 00 00 00 79 03 00 00 08 32 01 00 00 00 0E 00   ....y....2......   │
│000050   00 00 89 03 00 00 09 25 01 00 00 00 06 00 00 00   .......%........   │
│000060   58 01 00 00 08 20 01 00 00 00 2F 00 00 00 5E 01   X.... ..../...^.   │
│000070   00 00 08 22 01 00 00 00 7B 00 00 00 8D 01 00 00   ..."....{.......   │
│000080   08 33 01 00 00 00 18 00 00 00 97 03 00 00 08 34   .3.............4   │
│000090   01 00 00 00 14 00 00 00 AF 03 00 00 0B 30 02 00   ......../....0..   │
│0000A0   00 00 28 00 00 00 08 02 00 00 08 23 01 00 00 00   ..(........#....   │
│0000B0   0F 01 00 00 30 02 00 00 00 21 01 00 00 00 90 00   ....0....!......   │
│0000C0   00 00 C3 03 00 00 09 29 01 00 00 00 04 00 00 00   ..C....)........   │
│0000D0   53 04 00 00 00 00 00 00 00 00 00 00 00 00 7B 04   S.............{.   │
│0000E0   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00   ................   │
│0000F0   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00   ................   │
│000100   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00   ................   │
│000110   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00   ................   │
│000120   00 00 00 00 00 00 00 00 00 55 01 00 00 00 2E 00   .........U......   │
│000130   00 00 3F 03 00 00 00 00 00 00 00 00 00 00 00 00   ..?.............   │
│000140   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00   ................   │
╘══════════════════════════════════════════════════════════════════════════════╛
  and the end looks like this:

╒══════════════════════════════════════════════════════════════════════════════╕
│0003C0   00 00 00 00 01 FE FF 22 00 41 00 49 00 50 00 5B   .....~.".A.I.P.[   │
│0003D0   00 72 00 81 00 83 00 FF FF FF FF FF FF FF FF FF   .r..............   │
│0003E0   FF FF FF FF FF EF B3 88 45 3F FF FF FF FF FF FE   .....o3.E?.....~   │
│0003F0   FF CC CC 03 30 B3 1C CB CF 34 CC CF FC C0 C3 FC   .LL.03.KO4LO|@C|   │
│000400   0F FF 30 01 34 00 00 00 00 00 01 08 2F FF FF FF   ..0.4......./...   │
│000410   FF FF FF 4E B7 FF FF E0 04 05 00 00 00 02 AB 0F   ...N7..`......+.   │
│000420   FF F0 00 00 00 00 00 00 00 00 00 00 00 00 00 00   .p..............   │
│000430   00 00 00 00 F0 6D 70 CF 9F FF 89 04 40 00 00 00   ....pmpO....@...   │
│000440   00 00 00 04 03 F0 32 42 50 80 40 4C 4C 20 00 00   .....p2BP.@LL ..   │
│000450   00 00 00 01 00 0C 00 DD 0A 10 00 83 01 0A 00 03   .......]........   │
│000460   00 02 00 21 10 00 DD DD 0B 0B 00 03 00 00 57 0B   ...!..]]......W.   │
│000470   00 DD F1 02 02 00 F1 54 68 69 73 80 69 73 80 61   .]q...qThis.is.a   │
│000480   6E 80 65 78 61 6D 70 6C 65 2E F1 02 03 00 F1 D4   n.example.q...qT   │
│000490   25 0D 00 80 01 01 00 00 00 0D 00 D4 F1 03 03 00   %..........Tq...   │
│0004A0   F1 F1 03 02 00 F1                                 qq...q             │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
╘══════════════════════════════════════════════════════════════════════════════╛


Most users will care only about the sixteen columns at the right of the
screen, where the cursor will stay.  Those columns display the bytes in
your file (including the bytes in the prefix), usually as ascii
characters corresponding to what is stored in the file, although some
are displayed as dots.  (Remember that WPerf6 stores spaces  as the
ascii character Ç, or hex 80, decimal 128, which the Doctor displays as
a dot.)  In the rest of the screen, the first column of six digit
numbers has the offset, in hexadecimal, of the first byte displayed on
the line -- most users will, and should, ignore this column.  The next
sixteen columns of two digit numbers are the hexadecimal representation
of the sixteen bytes shown on the right.  Again, most users will, and
should, ignore the hexadecimal values.

You need to move around the document looking for the beginning of the
text and then put the cursor on the first character in the text (in
this case, the T in This).  In moving around the file, you can use
conventional cursor keys, PageUp and PageDown, Home to get to the
beginning of a line of sixteen characters, End to get to the end of it,
CtrlPgDown to get to the end of the file, and CtrlPgUp to get to the
beginning.

In addition to moving around with the cursor movement keys, you can
search for text automatically.  To search for a text string, hit CtrlQ
and then F.  You will be asked to enter the string.  Type it and hit
the Enter key.  You will be prompted for search options.  The valid
options are U, G, and B.  Enter as many of them as you want to use and
hit enter.  Option U is used if you want a case insensitive search; if
you do not use it, the search is case sensitive.  The other two options
control the search direction.  By default, the search is from the
cursor to the end of the file.  Option B results in a backward search
to the beginning of the file.  Option G will search the entire file.
To repeat a search, hit CtrlL.  Searching for strings has its limits; a
string will be matched only if it is found in the 16 columns of a
single line.  If your search string includes a blank space, remember to
represent it as Ç.

You may find it convenient to set "markers" (bookmarks) in the file --
candidate locations of the start of the text.  You can set up to four
markers, numbers 0 through 3.  To set a marker at the cursor location,
type CtrlK followed by the number of the marker.  You can jump to a
marker you have previously set by typing CtrlQ followed by the number
of the marker.

It is not always easy to find the beginning of the body of the
document.  Document prefixes can be many thousands of bytes long, so
you may have to do a lot of paging down.  And the prefix may contain
information that looks like it should be part of the text.  For
example, the document summary is contained in the prefix, and it may
contain a copy of part of the document text.  Styles are stored in the
prefix, and they may contain chunks of text.  Examine the display
carefully and try to avoid treating these chunks of text as the
beginning of the document.  (There is, unfortunately, another
circumstance making it impossible to find the beginning of the text
part of the document.  It is not always there.  If you do not see
anything resembling the start of your text anywhere in the display of
the file, your document is probably too badly damaged to be recovered,
or else it is a "locked" -- that is, password protected -- document.
The Doctor cannot fix locked documents.)

When you find the first word in the text, it may not be located at the
true beginning of the body of the document.  In fact, it almost never
will be, because WPerf6 almost invariably has an Initial Codes style at
the beginning of the body.  And there may be additional codes you will
not recognize.  For example, if the sentence in our example file had
been indented with a tab, the sentence would be preceded by a string of
bytes very few people would recognize as representing a tab.  Other
function codes at the start of a document are also represented by
unrecognizable strings of bytes.  For reasons explained below, function
codes like this are not a serious problem, and you should not worry
about them..

When you have decided on what to take as the beginning of the text of
the document, move the cursor to it and hit the ESC key.  The Doctor
will then display the offset of that location in the file as a
hexadecimal number.  You can edit that number, or you can simply hit
ENTER to accept it. It is difficult to imagine any circumstance in
which you would want to edit that number.

The Doctor then asks you whether you want it to search backwards
through the file for codes. Unless you have a very good reason for
answering N(o), you should answer Y(es).  If you do, the Doctor will
move backwards in the file from the offset you located, seeing if there
are valid WordPerfect codes.  If there are any, the Doctor will
consider them as part of the body of the document and adjust the offset
accordingly.  That is why you need not worry too much about codes like
tabs before the character you identify as the start of the text of the
document.  (This description may make it sound as though you could
simply move the cursor to the end of the file, treat that as the offset
of the beginning of the text, and let the Doctor do the work of finding
the beginning of the text part of the document.  Unfortunately, that
will not work, for two reasons. First, the Doctor will search backwards
only for about 15,000 bytes.  Second, the Doctor will stop searching
backwards the first time it finds an invalid code.  Since you would not
be using the Doctor if you knew the file to be in perfect shape, there
is a risk that there are invalid codes.) Backward searching may go too
far back, because the prefix may end with valid codes.  Extra codes
included as a result should not prove very troubling.

Once you have answered the backward searching question, the Doctor
processes your file. Remember that it may be necessary to use other
options afterwards.

Undo Undo

Unlike Strip Debris, which attempts to remove material stored in the
file only to handle the Undo function, Undo Undo removes the codes that
indicate material stored to handle the Undo function. Therefore, Undo
Undo can leave in the output file, as valid data, material that was
supposed to have been deleted.

Why do this?  The major, if not only, reason for doing this is to
handle the possibility that corruption (or another procedure) has
eliminated the code marking the end of Undo material.  In that case, it
is possible that WPerf6 would treat valid text as Undo material.  If
that were to happen, the valid text would be part of the file, but you
could not see it or use it in any way.  By turning such text back into
ordinary text, Undo Undo solves that problem.  Of course, you then have
the problem of getting rid of the Undo material again.

Kill Pair Codes

Many WPerf6 codes, like the codes that mark Undo material, come in
pairs.  And if one member of the pair becomes damaged or lost, WPerf6
can get confused.  Kill Pair Codes eliminates the problem by getting
rid of all paired codes.

This is harsh medicine.  Paired codes tend to surround other things so
that WPerf6 knows they are special.  For example, paired codes surround
footnote numbers in the text.  The codes give those numbers their
characteristic properties of referring to footnote text and changing
value as you add, delete, or move footnotes.  If you remove the paired
codes, the footnote numbers become ordinary numbers, fixed forever at
their current values, and not linked to actual footnotes. They become
simply numbers in the text.  Similar stories can be told about other
types of paired codes.  In sum, Kill Pair Codes can cause havoc for
your footnotes, lists, tables of contents, included subdocuments, and
much else.  All these things lose their special properties and become,
at best, simply ordinary text.

Why inflict such damage on a document?  Because it may be necessary in
order to make the document usable at all.

Unfortunately, it may be necessary to Kill Pair Codes after removing
bad references.  This is because the opening member of a pair often
refers to material in the document prefix, and removing the bad
reference removes the opening code in the pair.  And since removing the
entire prefix of a document is likely to create many bad references,
the sequence Drastic Surgery, Remove Bad References, Kill Pair Codes
arises fairly often.

Fix Spurious Password

Both WordPerfect and Doctor 6 will occasionally report that a document
file is password protected (encrypted) when in fact it is not.  This
happens when certain bytes in the file, the ones that tell WordPerfect
(and Doctor 6) that the file is password protected, are corrupted and
convey the wrong information.  Fix Spurious Password rewrites those
bytes to indicate that the file is not password protected.  This option
will NOT decrypt a file or remove password protection.  It is helpful
ONLY if the file is not actually password protected, not actually
encrypted.


                          Using SaveText


Text stored in the prefix of a document may become inaccessible, either
because you have used Drastic Surgery to remove the prefix, or because
a code's reference to that text has become corrupted.  The loss of
prefix text can be troubling, because although some prefix text is not
particularly important and can easily be replaced (headers and footers,
for example), other prefix text, such as footnotes and the contents of
boxes, can be very important to the document.

SaveText, a companion program to Doctor 6, can sometimes preserve
prefix text that would otherwise be lost.  It does this by copying text
from the prefix of one WPerf6 document to the body of a new WPerf6
document it creates.  If this operation is successful, you can
reconstruct the original document, using text from the body of the
newly-created document as appropriate. Unfortunately, SaveText cannot
tell you what function the text it saves served in its original
location -- it cannot tell a footnote from an equation box.  It simply
labels each block of text with the sequence number of the data packet
in the prefix where it was found.  (These sequence numbers are the same
as the ones shown in Doctor 6's Erase Selected Prefix Data display.)
Note that SaveText will not copy the text of any prefix data packet
that Doctor 6 cannot process.

SaveText will not always work, and can even crash badly.  We think it
would always work if it were used only on uncorrupted files.  Of
course, if the file were not corrupted, you would probably have no use
for SaveText.  SaveText will, however, work on many corrupted files.
It performs certain checks on the file prefix to see if the document is
too far gone for the program to work, but it does not perform as many
checks as the Doctor's Prefix Check option.  Therefore, SaveText will
attempt to process certain files that flunk the Prefix Check, but it
perhaps will also crash during processing. If SaveText refuses to
process the file, you may be able to force processing by using the
prefix-repairing capability of Prefix Check before running SaveText.

The output file SaveText creates may itself be corrupt, because it may
include text from the prefix that itself was corrupt or because the
saved text include references to material in the old prefix that is not
found in the prefix of the new output file (since the prefix of the
output file contains, for all practical purposes, nothing).  Doctor 6
should be able to fix such an output file.

SaveText is not interactive.  You run it entirely from the DOS command
line:

   C:\DR6>SaveText Infile Outfile

   Infile is the name (with drive and path, if necessary) of the file
     whose prefix text you wish to save.

   Outfile is the name (with drive and path, if necessary) of the file
     in which SaveText will write the Infile prefix text.  If Outfile
     already exists, it will be overwritten.



                             Using TestSix


TestSix is a DOS command-line program that performs the same diagnostic
functions as Doctor 6.  Although some users may find TestSix a more
convenient way to test a single file than Doctor 6, the primary reason
for using TestSix is to check large numbers of files for corruption.
TestSix is much faster than Doctor 6 for checking multiple files,
because it can process wildcard file specifications, and even entire
disks at a single pass.  Moreover, it reports its results with at most
a single line of output per file tested.

Results are indicated by a two-letter code, followed by the full path
specification of the file tested.  For example,

         OK K:\TEST\BOOK\PART-Z.WPD

indicates that file PART-Z.WPD in subdirectory test\book on drive K
successfully passed every diagnostic test.  ("OK" does not mean that
the file is not corrupt, because some forms of corruption are not found
by the diagnostic tests.)

In addition to OK, the two-letter codes and their meanings are as
follows:

         NF      File not found
         NP      No prefix (fewer than 16 bytes in the file)
         5X      A WordPerfect 5.x document file
         N6      Not a WordPerfect 6.x document file
         EN      Encrypted (password protected) WPerf6 document
         BS      Bad starting point for document body indicated
         NI      No indexes found in prefix
         PL      Data packet length indicated is invalid
         OP      Overlapping data packets indicated
         PO      Data packets overlap document body
         BC      Bad codes found
         BR      Bad references found
         UU      Unbalanced undo codes found

Note that a file may have more than one form of corruption.  TestSix,
however, reports only the first form found.

If you are testing large numbers of files, the default output may be
more voluminous than is convenient.  For example, if you are testing
1,000 WordPerfect 6 document files, and three of these fail a
diagnostic test, you will have 997 lines of output listing files that
are "OK."  As indicated below, options allow you to restrict the output
to that which is likely to be interesting and useful.

TestSix is invoked from the DOS command line this way

         c:\dr6\>TESTSIX Infile [Infile .. Infile] [options]

         Infile is a file specification, which normally would include
         the full path specification of the file(s) to be tested, and
         which may, and usually will, include wildcards (* or ?).
         TESTSIX will test every file matching the wildcard
         specification.

         -- At least one Infile must appear on the command line, but
         you may include as many as five.

         -- You may also use an "indirect" specification of files to be
         tested.  If an Infile on the command line is preceded by @
         (e.g., @c:\wp60\flist), the file is not a file for TestSix to
         test, but instead an ASCII text file containing a list of
         Infiles, one per line. (If you want to use TestSix on a WPerf6
         file whose name begins with @, you must either specify that
         file in an indirect file rather than on the command line, or
         else include the path, e.g., c:\wp60\@flist as an infile tests
         the file @flist, found in the c:\wp60 subdirectory).

         Output goes to standard output (by default the screen), and
         normally should be piped or redirected.

         Options

         Each option is specified by - or / preceding a single letter,
         e.g., -E or /E.  If you use two options, you can specify them
         separately (e.g., -E -O) or combine them (e.g., -EO).  There
         is never any reason to use more than two options, since all
         the options other than E are mutually exclusive.

         -E      Any wildcard Infile is processed not only in the
                 indicated subdirectory, but also in every subdirectory
                 hierarchically below that subdirectory in the
                 directory tree.  Thus, for example, c:\*.*, if used
                 with the -E option, would process every file on drive
                 c.

         -F      Output includes a line for every file processed.  This
                 is the default option, and there is never any need to
                 specify it (but it is not an error if you do).

         -O      Output includes a line for each file with the code OK,
                 and for no other files.

         -B      Output includes a line for each file found to be
                 corrupted (bad), and for no other files.

         -N      Output includes a line for each file that does not
                 receive the code OK.

         The difference between -B and -N may be obvious, but in case
         it is not, note that files with the codes NF, NP, 5X, N6 or EN
         would be reported by the -N option but not the -B option,
         because although they were not found to be OK, they were also
         not found to be corrupted WordPerfect 6 files -- they were not
         found at all, were not found to be WordPerfect 6 files, or
         were found to be encrypted so they could not be further
         tested.

Examples

         >TestSix c:\wpdocs\*.* -B >c:\admin\badstuff.txt

         Tests every file in subdirectory wpdocs, reports only those
         files found to be corrupted, and writes the report to file
         badstuff.txt in subdirectory admin of drive c:.

         >TestSix c:\wpdocs\*.mem -EN |list /s

         Tests every file with the extension mem in subdirectory wpdocs
         of drive c: and every such file in subdirectories under
         wpdocs, reports only those files found not to be OK, and pipes
         the results to Vern Burg's LIST program.

         >TestSix @c:\myfiles\test.em >prn

         Tests every file matching a file specification found in ascii
         text file c:\myfiles\test.em, reports on all such files, and
         sends the report to the printer.  File test.em might look
         something like this:

c:\wpdocs\memos\*.*
c:\wpdocs\letters\*.95
d:\misc\*.*

         Using Test6

Test6.dll provides exactly the same diagnostic capabilities as TestSix,
in the form of functions you can call from WordPerfect for Windows
macros or from programs written in any language capable of calling
functions in a DLL.  You could, for example, write a macro that
retrieves a file only if the file tests out as not corrupted.  This
documentation assumes you know how to call functions in DLLs.  The
functions are documented here primarily as Pascal function headers,
with a little explanation for the benefit of C programmers and with
examples of how to call the functions from WPerf6.1/Win macros.

The easy way to use Test6 is to use the function TestAFile, which does
all of the TestSix testing on a single specified file (wildcards will
NOT work).  Here is the function header:

Function TestAFile(TheFileName:pchar):word;

         "pchar" identifies TheFileName as a pointer to a null-
         terminated string.  The function returns a word-sized number.
         The numbers correspond to the two-letter codes displayed by
         TestSix:

         0       OK
         10      File not found
         1       No prefix (fewer than 16 bytes in the file)
         9       A WordPerfect 5.x document file
         2       Not a WordPerfect 6.x document file
         3       Encrypted (password protected) WPerf6 document
         4       Bad starting point for document body indicated
         5       No indexes found in prefix
         6       Data packet length indicated is invalid
         7       Overlapping data packets indicated
         8       Data packets overlap document body
         11      Bad codes found
         12      Bad references found
         13      Unbalanced undo codes found


Here is a sample macro using the function:

APPLICATION(A1; "WordPerfect"; Default; "US")
DLLLOAD (htest; "D:\DR6\test6.Dll")
TheFile := "K:\test\aussie\filing.b"
DLLCALL(htest;"TestAFile";wResult:WORD; {TheFile});
MessageBox(RetVal;"The Result Is";wResult;)
DLLFREE(htest)
QUIT

The hard way is to use one function call to open the file, then one
function call for each of the tests you want to perform, and finally
another function call to close the file and otherwise clean up.  If you
choose the hard way (which in some situations might be slightly faster
in execution), it is your responsibility to see that the tests you
perform make sense.  If, for example, the file is encrypted, or has no
prefix, it does not make sense to test whether there are bad codes in
the body of the document.  The effect of running a senseless test may
be unpredictable; you do NOT want to try it.

If you are doing it the hard way, you MUST begin with a call to
OpenTheFile.  It returns a word- sized boolean value, which you can
simply treat as a word that has the value 0 for false and 1 for true.

function OpenTheFile(TheFileName:pchar):WordBool;

         The function returns True (1) if it successfully opens the
         file, and False (0) otherwise.

If you have opened the file, you MUST close it, and perform other
cleanup operations, when you are finished testing, and before you test
a second file.  Therefore, the hard way (with respect to any particular
file) ends with a call to CloseTheFile:

function CloseTheFile:WordBool;

         CloseTheFile returns word-sized boolean value, but you should
         ignore it.

If you have successfully opened the file, you can run some tests on it.
The first battery of tests you should run checks the file prefix and
returns a word-sized number:

function CheckThePrefix:word;

         Note that no file is specified; the tests are performed on the
         file previously opened by OpenTheFile.  Do NOT call
         CheckThePrefix if no file has been opened by OpenTheFile.

         The function returns a number from 0 to 9.  The numbers 1-9
         correspond to the same numbers as returned by TestAFile.  Zero
         has a different meaning; it means only that CheckThePrefix
         found no problem.

If CheckThePrefix returns zero, but not otherwise, you might want to
perform other tests as well.  There are three:

function CheckTheCodes:WordBool;
function CheckTheReferences:WordBool;
function CheckTheUndo:WordBool;

         In each case, the function performs a test which should be
         obvious is you have read the rest of this documentation.  The
         result is True if the function finds a problem, and False
         otherwise (which may be the reverse of what makes sense to
         you).

The example below checks the prefix and then the codes for a single
file:

The example below checks the prefix and then the codes for a single
file:

APPLICATION(A1; "WordPerfect"; Default; "US")
DLLLOAD (htest; "D:\DR6\test6.Dll")
TheFile := "K:\test\aussie\filing"
DLLCALL(htest;"OpenTheFile";wResult:WORD; {TheFile})
IF (wresult)
      DLLCALL(htest; "CheckThePrefix";wResult:WORD;{})
      MessageBox(RetVal;"The Prefix Result Is";wResult;)
ELSE
      MessageBox(RetVal;"Problems Opening This File";TheFile)
      DLLCALL(htest; "CloseTheFile";wResult:WORD;{})
      DLLFREE(htest)
      Quit
ENDIF
IF (wresult = 0)
      DLLCALL(htest; "CheckTheCodes";wResult:WORD;{})
      IF (wResult)
         MessageBox(RetVal;"Bad Codes in ";TheFile)
      ENDIF
ENDIF
DLLCALL(htest; "CloseTheFile";wResult:WORD;{})
DLLFREE(htest)
QUIT


Modifications of this macro to use CheckTheReferences and/or
CheckTheUndo should be obvious.


                              Getting Help


Help in using Doctor 6 and SaveText is available by mail, telephone,
and E-mail.  The best time for telephone calls is weekdays 8pm-11pm
Eastern time.  At other hours, you are likely to reach only an
answering machine.  E-mail and fax are recommended.

David Seidman
Software by Seidman
2737 Devonshire Pl. NW
Washington, DC 20008
202/462-7381
FAX: [phone]
CompuServe: [70441,2414]
Internet:    [e-mail]
             [e-mail]

                          License Information


Doctor 6 is not in the public domain.  It is fully protected by
copyright.

For purposes of evaluation and testing only, Doctor 6 is distributed as
shareware, along with the documentation in ASCII format only (but
without SaveText, TestSix, and Test6, the "associated utilities").
Anyone receiving the shareware distribution is granted without charge a
license which permits (a) use of the program for a reasonable period of
time for evaluation and testing; (b) making copies for distribution to
others without charge, provided the program and the accompanying
documentation are distributed together and without modification; (c)
posting the program, together with the accompanying documentation, on
electronic bulletin board systems.  A reasonable period of time is two
weeks following successful use of Doctor 6 to repair a file. The
permissions granted in this paragraph do NOT apply to the associated
utilities or to the documentation in WordPerfect format.

Use after the evaluation and testing period requires payment of a
license fee (sometimes referred to as a registration fee).  For a
single copy (plus necessary archival copies), to be used on only one
computer at a time, the fee is $35.00.  For large quantities, discounts
and site licenses are available.  Write for information.

When you pay the registration (license) fee, we will send you the
latest version of Doctor 6 and the associated utilities, as well as
documentation in WordPerfect format.  Any license for which payment is
properly made is valid for this version of Doctor 6 and the associated
utilities and all subsequent minor version changes.  For major version
changes (the major version is indicated by the number to the left of
the decimal point -- this version is 2.0, and the next major version
would be 3.0), we reserve the right to charge a license upgrade fee,
but we may or may not require such a fee for major version upgrades.

The license permits you to use Doctor 6 and the associated utilities on
one computer at a time (and to make archival copies).  It also permits
you to make as many copies of the documentation as you need for your
own use.  We will attempt to send you notification of new versions.
And if you let us know about any problems you have with the programs,
we will try to solve them.

The United States Department of Justice is granted a license, without
payment of fee, for all official use of Doctor 6 and the associated
utilities.

                          Warranty Information


These programs are distributed without warranties of any kind, express
or implied, including, but not limited to, the implied warranties of
merchantability and fitness for a particular purpose.

No representation or other affirmation of fact, including but not
limited to statements regarding suitability for use, or performance of
the programs, shall be or be deemed a warranty by the licensor for any
purpose, nor give rise to any liability or obligation of the licensor
whatever.

In particular, no statement in program documentation shall be deemed a
representation or warranty that the programs will perform in any
particular manner, or perform in any manner whatsoever, or that the
programs are suitable for any particular use or any use at all.
************************************************************************

                                INVOICE


David Seidman
Software by Seidman
2737 Devonshire Place, N. W.
Washington, D. C. 20008

                                              DATE:

SOLD TO:

__________________________
__________________________
__________________________


┌───────────────────────────────────┬──────┬────────────────────────┐
│ Description                       │ Qty. │     Price              │
│                                   │      │                        │
├───────────────────────────────────┼──────┼────────────────────────┤
│                                   │      │                        │
│ Licensed copy of Doctor6 @US$35.00│      │      $_____.__         │
│                                   │      │                        │
│ Licensed copy of Doctor 6 for     │      │                        │
│  registered user of WPMD          │      │                        │
│                        @US$25.00  │      │       _____.__         │
│                                   │      │                        │
│                                   │      │                        │
└───────────────────────────────────┴──────┴────────────────────────┘

                                Total:                $_____.__
 D.C. Residents add D.C. Sales Tax (5.75%)               ___.__

                                Total Charge:         $_____.__


Make checks payable to Software by Seidman.  Please mark checks
"Doctor 6".

For Credit Card orders, Circle one:   VISA   MasterCard  Diners Club

Card Number:     __________________________  Exp. Date: _____________

Name on card:    __________________________________________________

Signature:       __________________________________________________